{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/sharedata/mdy/miniforge/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    },
    {
     "ename": "ImportError",
     "evalue": "attempted relative import with no known parent package",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mImportError\u001b[0m                               Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[1], line 6\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mtransformers\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mmodels\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mllama\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mmodeling_llama\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m LlamaRMSNorm\n\u001b[1;32m      5\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mcopy\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m deepcopy\n\u001b[0;32m----> 6\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mmdy_triton\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mcore\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mrmsnorm\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m TritonRMSNorm\n",
      "\u001b[0;31mImportError\u001b[0m: attempted relative import with no known parent package"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import triton\n",
    "import triton.language as tl\n",
    "from transformers.models.llama.modeling_llama import LlamaRMSNorm\n",
    "from copy import deepcopy\n",
    "import os\n",
    "import sys\n",
    "sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__),\n",
    "                                             os.path.pardir)))\n",
    "from mdy_triton.core.rmsnorm import TritonRMSNorm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 进一步优化，将add和norm的操作进行融合\n",
    "- 比单独优化norm，又提速大概30%"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Core"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@triton.jit\n",
    "def _add_rmsnorm_fwd(X, OLD_RESIDUAL, W, NEW_RESIDUAL, Y, RMS_STD, eps,\n",
    "                 row_stride,\n",
    "                 N,\n",
    "                 BLOCK_N:tl.constexpr):\n",
    "    row_id = tl.program_id(0)\n",
    "    cols = tl.arange(0, BLOCK_N)\n",
    "    mask = cols < N\n",
    "\n",
    "    x = tl.load(X + row_id * row_stride + cols, mask=mask, other=0.).to(tl.float32)\n",
    "    old_residual = tl.load(OLD_RESIDUAL + row_id * row_stride + cols, mask=mask, other=0.).to(tl.float32)\n",
    "    new_residual = x + old_residual\n",
    "    tl.store(NEW_RESIDUAL + row_id * row_stride + cols, new_residual, mask=mask)\n",
    "    \n",
    "    w = tl.load(W+cols, mask=mask, other=0.).to(tl.float32)\n",
    "\n",
    "    rms_std = tl.sqrt(tl.sum(new_residual * new_residual) / N + eps)\n",
    "    new_residual_hat = new_residual / rms_std\n",
    "    y = new_residual_hat * w\n",
    "\n",
    "    tl.store(Y + row_id * row_stride + cols, y, mask=mask)\n",
    "    tl.store(RMS_STD + row_id, rms_std)\n",
    "\n",
    "@triton.jit\n",
    "def _add_rmsnorm_bwd_dx_fused(DX, DW, DOLD_RES, DNEW_RES, DY, NEW_RES, W, RMS_STD,\n",
    "                            row_stride,\n",
    "                            M, N,\n",
    "                            BLOCK_N:tl.constexpr\n",
    "                            ):\n",
    "    \n",
    "    start_id = tl.program_id(0)\n",
    "    cols = tl.arange(0, BLOCK_N)\n",
    "    mask = cols < N\n",
    "\n",
    "    dw = tl.zeros([BLOCK_N,], dtype=tl.float32)\n",
    "    for row_id in range(start_id, M, tl.num_programs(0)):\n",
    "\n",
    "        new_res = tl.load(NEW_RES + row_id * row_stride + cols, mask=mask, other=0.).to(tl.float32)\n",
    "        w = tl.load(W + cols, mask=mask, other=0.).to(tl.float32)\n",
    "        dy = tl.load(DY + row_id * row_stride + cols, mask=mask, other=0.).to(tl.float32)\n",
    "        rms_std = tl.load(RMS_STD + row_id)\n",
    "\n",
    "        new_res_hat = new_res / rms_std\n",
    "        wdy = w * dy\n",
    "        dnew_res = (wdy - (new_res_hat / N) * tl.sum(new_res_hat * wdy)) / rms_std\n",
    "        dnew_res += tl.load(DNEW_RES + row_id * row_stride + cols, mask=mask, other=0.).to(tl.float32)\n",
    "        tl.store(DX + row_id * row_stride + cols, dnew_res, mask=mask)\n",
    "        tl.store(DOLD_RES + row_id * row_stride + cols, dnew_res, mask=mask)\n",
    "\n",
    "        dw += new_res_hat * dy\n",
    "    tl.store(DW + start_id * row_stride + cols, dw, mask=mask)\n",
    "\n",
    "\n",
    "\n",
    "class _TritronFusedAddRMSNorm(torch.autograd.Function):\n",
    "\n",
    "    @staticmethod\n",
    "    def forward(ctx, hidden_state, old_residual, weight, eps):\n",
    "        ctx.input_shape = hidden_state.shape\n",
    "        output = torch.empty_like(hidden_state)\n",
    "        new_residual = torch.empty_like(hidden_state)\n",
    "        hidden_state = hidden_state.reshape(-1, ctx.input_shape[-1])\n",
    "        M,N = hidden_state.shape\n",
    "        BLOCK_N = triton.next_power_of_2(N)\n",
    "        rms_std = torch.empty(M, dtype=torch.float32, device=hidden_state.device)\n",
    "        \n",
    "        _add_rmsnorm_fwd[(M,)](hidden_state, old_residual, weight, new_residual, output, rms_std, eps,\n",
    "                            hidden_state.stride(0),\n",
    "                            N,\n",
    "                            BLOCK_N,\n",
    "                            )\n",
    "        ctx.save_for_backward(hidden_state, new_residual, weight, rms_std)\n",
    "        return output, new_residual\n",
    "    \n",
    "    @staticmethod\n",
    "    def backward(ctx, dy, dnew_res, *args):\n",
    "        hidden_state, new_residual, weight, rms_std = ctx.saved_tensors\n",
    "        M,N = hidden_state.shape\n",
    "\n",
    "\n",
    "        BLOCK_N = min(128, triton.next_power_of_2(N))\n",
    "\n",
    "        NUM_SMS = torch.cuda.get_device_properties('cuda').multi_processor_count\n",
    "        dw = torch.empty(NUM_SMS, N, dtype=torch.float32, device=weight.device)\n",
    "        dx = torch.empty_like(dy)\n",
    "        dold_residual = torch.empty_like(dy)\n",
    "\n",
    "        _add_rmsnorm_bwd_dx_fused[(NUM_SMS,)](dx, dw, dold_residual, dnew_res, dy, new_residual, weight, rms_std,\n",
    "                                hidden_state.stride(0), \n",
    "                                M, N, BLOCK_N)\n",
    "        return dx, dold_residual, dw, None\n",
    "\n",
    "triton_fused_add_norm = _TritronFusedAddRMSNorm.apply\n",
    "class TritonFusedAddRMSNorm(torch.nn.Module):\n",
    "    def __init__(self, hidden_size, eps=1e-6):\n",
    "        super().__init__()\n",
    "        self.weight = torch.nn.Parameter(torch.ones(hidden_size))\n",
    "        self.eps = eps\n",
    "    \n",
    "    def forward(self, hidden_state, old_residual):\n",
    "        return triton_fused_add_norm(hidden_state, old_residual, self.weight, self.eps)\n",
    "\n",
    "class TritonAddRMSNorm(torch.nn.Module):\n",
    "    def __init__(self, hidden_size, eps=1e-6):\n",
    "        super().__init__()\n",
    "        self.norm = TritonRMSNorm(hidden_size, eps)\n",
    "    \n",
    "    def forward(self, hidden_state, old_residual):\n",
    "        new_residual = hidden_state + old_residual\n",
    "        output = self.norm(new_residual)\n",
    "        return output, new_residual\n",
    "    \n",
    "class LlamaAddRMSNorm(torch.nn.Module):\n",
    "    def __init__(self, dim, eps=1e-6):\n",
    "        super().__init__()\n",
    "        self.norm = LlamaRMSNorm(hidden_size=dim, eps=eps)\n",
    "\n",
    "    def forward(self, hidden_state, old_residual):\n",
    "        new_residual = hidden_state + old_residual\n",
    "        output = self.norm(new_residual)\n",
    "        return output, new_residual"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 精度测试"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# bf16的grad误差有点大\n",
    "dtype = torch.float32\n",
    "device = 'cuda'\n",
    "rtol = 1e-8\n",
    "atol = 1e-4\n",
    "dim = 8\n",
    "x1 = torch.randn(4, dim).to(device).to(dtype)\n",
    "res1 = torch.randn(4, dim).to(device).to(dtype)\n",
    "x1.requires_grad_(True)\n",
    "res1.requires_grad_(True)\n",
    "x2 = deepcopy(x1)\n",
    "res2 = deepcopy(res1)\n",
    "fused_add_norm = TritonFusedAddRMSNorm(dim).to(device).to(dtype)\n",
    "llama_add_norm = LlamaAddRMSNorm(dim).to(device).to(dtype)\n",
    "fused_add_norm.weight.data.copy_(llama_add_norm.norm.weight.data)\n",
    "y1, new_res1 = fused_add_norm(x1,res1)\n",
    "y2, new_res2 = llama_add_norm(x2,res2)\n",
    "print(torch.allclose(y1,y2, rtol=rtol, atol=atol))\n",
    "print(torch.allclose(new_res1,new_res2, rtol=rtol, atol=atol))\n",
    "k = torch.rand_like(x1).T # 乘上结果，防止dy，dres的stride都为0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "if x1.grad is not None:\n",
    "    x1.grad.zero_()\n",
    "    res1.grad.zero_()\n",
    "loss = (y1 + new_res1) @ k\n",
    "loss.sum().backward(retain_graph=True)\n",
    "\n",
    "if x2.grad is not None:\n",
    "    x2.grad.zero_()\n",
    "    res2.grad.zero_()\n",
    "loss = (y2 + new_res2) @ k\n",
    "loss.sum().backward(retain_graph=True)\n",
    "\n",
    "print(torch.allclose(x1.grad, x2.grad, rtol=rtol, atol=atol))\n",
    "print(torch.allclose(res1.grad, res2.grad, rtol=rtol, atol=atol))\n",
    "print(torch.allclose(fused_add_norm.weight.grad, llama_add_norm.norm.weight.grad, rtol=rtol, atol=atol))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# forward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSNorm:\n",
      "    seq_len  Triton-FusedAddRMSNorm  HF-LlamaAddRMSNorm  Triton-AddRMSNorm\n",
      "0     128.0               20.262375          141.072676              100.0\n",
      "1     256.0               34.231715          261.659563              100.0\n",
      "2     384.0               48.257962          367.179602              100.0\n",
      "3     512.0               61.934441          473.501146              100.0\n",
      "4     640.0               75.566716          590.768635              100.0\n",
      "5     768.0               89.440361          694.177210              100.0\n",
      "6     896.0              102.969579          799.697399              100.0\n",
      "7    1024.0              117.101230          908.347189              100.0\n",
      "8    1152.0              131.837562         1020.819902              100.0\n",
      "9    1280.0              145.477235         1125.690579              100.0\n",
      "10   1408.0              159.213692         1232.349396              100.0\n",
      "11   1536.0              173.537970         1341.340423              100.0\n",
      "12   1664.0              187.632844         1451.308012              100.0\n",
      "13   1792.0              201.400653         1555.129528              100.0\n",
      "14   1920.0              216.732204         1658.886313              100.0\n",
      "15   2048.0              229.490817         1766.502619              100.0\n"
     ]
    }
   ],
   "source": [
    "torch.cuda.empty_cache()\n",
    "@triton.testing.perf_report(\n",
    "    triton.testing.Benchmark(\n",
    "        x_names=['seq_len'],  # argument names to use as an x-axis for the plot\n",
    "        x_vals=[128 * i for i in range(1, 16+1)],  # different possible values for `x_name`\n",
    "        line_arg='provider',  # argument name whose value corresponds to a different line in the plot\n",
    "        line_vals=['Triton-FusedAddRMSNorm', 'HF-LlamaAddRMSNorm', 'Triton-AddRMSNorm'],  # possible values for `line_arg``\n",
    "        line_names=[\n",
    "            \"Triton-FusedAddRMSNorm\",\n",
    "            \"HF-LlamaAddRMSNorm\",\n",
    "            \"Triton-AddRMSNorm\"\n",
    "        ],  # label name for the lines\n",
    "        styles=[('blue', '-'), ('green', '-'), ('orange', '-')],  # line styles\n",
    "        ylabel=\"ms\",  # label name for the y-axis\n",
    "        plot_name=\"RMSNorm\",  # name for the plot. Used also as a file name for saving the plot.\n",
    "        args={'dim': 3584, 'bs': 16}\n",
    "\n",
    "    ))\n",
    "def benchmark(bs, seq_len, dim, provider):\n",
    "    device = torch.device('cuda')\n",
    "    dtype = torch.float16\n",
    "    x = torch.randn(bs, seq_len, dim).to(device).to(dtype)\n",
    "    res = torch.randn_like(x)\n",
    "    stream = torch.cuda.Stream()\n",
    "    torch.cuda.set_stream(stream)\n",
    "    if provider == 'HF-LlamaAddRMSNorm':\n",
    "        func = LlamaAddRMSNorm(dim).cuda().to(dtype)\n",
    "        ms = triton.testing.do_bench(lambda: func(x, res))\n",
    "    if provider == 'Triton-FusedAddRMSNorm':\n",
    "        func = TritonFusedAddRMSNorm(dim).cuda().to(dtype)\n",
    "        ms = triton.testing.do_bench(lambda: func(x, res))\n",
    "    if provider == 'Triton-AddRMSNorm':\n",
    "        return 100\n",
    "        func = TritonAddRMSNorm(dim).cuda().to(dtype)\n",
    "        ms = triton.testing.do_bench(lambda: func(x, res))\n",
    "\n",
    "    return ms * 1e3\n",
    "benchmark.run(show_plots=True, print_data=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSNorm:\n",
      "        dim  Triton-FusedAddRMSNorm  HF-LlamaAddRMSNorm  Triton-AddRMSNorm\n",
      "0    1024.0               31.710621          138.045847          35.974726\n",
      "1    2048.0               48.747953          294.148326          60.499687\n",
      "2    3072.0               68.196461          418.942600          88.117898\n",
      "3    4096.0               87.716311          543.123066         109.881751\n",
      "4    5120.0              106.250919          661.918521         134.328648\n",
      "5    6144.0              125.632167          782.863259         157.950401\n",
      "6    7168.0              145.355403          901.360810         181.738034\n",
      "7    8192.0              164.657921         1023.736954         205.208376\n",
      "8    9216.0              184.917554         1145.316839         228.349313\n",
      "9   10240.0              205.888644         1264.269948         252.686918\n",
      "10  11264.0              223.854020         1387.601256         276.900887\n",
      "11  12288.0              243.461847         1509.976625         300.419778\n",
      "12  13312.0              263.306916         1629.718781         323.350698\n",
      "13  14336.0              282.465309         1746.948242         347.538203\n",
      "14  15360.0              302.002847         1866.227150         371.992499\n",
      "15  16384.0              322.600156         1985.352874         395.745784\n"
     ]
    }
   ],
   "source": [
    "torch.cuda.empty_cache()\n",
    "@triton.testing.perf_report(\n",
    "    triton.testing.Benchmark(\n",
    "        x_names=['dim'],  # argument names to use as an x-axis for the plot\n",
    "        x_vals=[1024 * i for i in range(1, 16+1)],  # different possible values for `x_name`\n",
    "        line_arg='provider',  # argument name whose value corresponds to a different line in the plot\n",
    "        line_vals=['Triton-FusedAddRMSNorm', 'HF-LlamaAddRMSNorm', 'Triton-AddRMSNorm'],  # possible values for `line_arg``\n",
    "        line_names=[\n",
    "            \"Triton-FusedAddRMSNorm\",\n",
    "            \"HF-LlamaAddRMSNorm\",\n",
    "            \"Triton-AddRMSNorm\"\n",
    "        ],  # label name for the lines\n",
    "        styles=[('blue', '-'), ('green', '-'), ('orange', '-')],  # line styles\n",
    "        ylabel=\"ms\",  # label name for the y-axis\n",
    "        plot_name=\"RMSNorm\",  # name for the plot. Used also as a file name for saving the plot.\n",
    "        args={'seq_len': 1024, 'bs': 4}\n",
    "\n",
    "    ))\n",
    "def benchmark(bs, seq_len, dim, provider):\n",
    "    device = torch.device('cuda')\n",
    "    dtype = torch.float16\n",
    "    x = torch.randn(bs, seq_len, dim).to(device).to(dtype)\n",
    "    res = torch.randn_like(x)\n",
    "    stream = torch.cuda.Stream()\n",
    "    torch.cuda.set_stream(stream)\n",
    "    if provider == 'HF-LlamaAddRMSNorm':\n",
    "        func = LlamaAddRMSNorm(dim).cuda().to(dtype)\n",
    "        ms = triton.testing.do_bench(lambda: func(x, res))\n",
    "    if provider == 'Triton-FusedAddRMSNorm':\n",
    "        func = TritonFusedAddRMSNorm(dim).cuda().to(dtype)\n",
    "        ms = triton.testing.do_bench(lambda: func(x, res))\n",
    "    if provider == 'Triton-AddRMSNorm':\n",
    "        func = TritonAddRMSNorm(dim).cuda().to(dtype)\n",
    "        ms = triton.testing.do_bench(lambda: func(x, res))\n",
    "\n",
    "    return ms * 1e3\n",
    "benchmark.run(show_plots=True, print_data=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# backward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bs: 8, seq_len: 1024\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSNorm:\n",
      "    seq_len  Triton-FusedAddRMSNorm  HF-LlamaAddRMSNorm  Triton-AddRMSNorm\n",
      "0     128.0              191.466376          252.427757         239.099860\n",
      "1     256.0              196.827993          359.723687         211.279824\n",
      "2     384.0              184.037894          547.802269         212.717444\n",
      "3     512.0              188.113719          719.688952         227.917343\n",
      "4     640.0              184.778765          880.068481         232.668281\n",
      "5     768.0              213.142991         1031.508327         270.947516\n",
      "6     896.0              242.430732         1186.484694         310.395986\n",
      "7    1024.0              272.667140         1335.644007         348.534703\n",
      "8    1152.0              300.763249         1484.498262         386.514902\n",
      "9    1280.0              330.199301         1632.653236         424.311280\n",
      "10   1408.0              360.058218         1784.955978         457.288295\n",
      "11   1536.0              385.740548         1936.439991         492.984265\n",
      "12   1664.0              414.917201         2089.616060         534.620106\n",
      "13   1792.0              443.654567         2247.162342         572.994471\n",
      "14   1920.0              471.835703         2396.984100         610.919476\n",
      "15   2048.0              501.624525         2542.508841         645.638585\n"
     ]
    }
   ],
   "source": [
    "torch.cuda.empty_cache()\n",
    "@triton.testing.perf_report(\n",
    "    triton.testing.Benchmark(\n",
    "        x_names=['seq_len'],  # argument names to use as an x-axis for the plot\n",
    "        x_vals=[128 * i for i in range(1, 16+1)],  # different possible values for `x_name`\n",
    "        line_arg='provider',  # argument name whose value corresponds to a different line in the plot\n",
    "        line_vals=['Triton-FusedAddRMSNorm', 'HF-LlamaAddRMSNorm', 'Triton-AddRMSNorm'],  # possible values for `line_arg``\n",
    "        line_names=[\n",
    "            \"Triton-FusedAddRMSNorm\",\n",
    "            \"HF-LlamaAddRMSNorm\",\n",
    "            \"Triton-AddRMSNorm\"\n",
    "        ],  # label name for the lines\n",
    "        styles=[('blue', '-'), ('green', '-'), ('orange', '-')],  # line styles\n",
    "        ylabel=\"ms\",  # label name for the y-axis\n",
    "        plot_name=\"RMSNorm\",  # name for the plot. Used also as a file name for saving the plot.\n",
    "        args={'dim': 4096, 'bs': 4}\n",
    "\n",
    "    ))\n",
    "def benchmark(bs, seq_len, dim, provider):\n",
    "    device = torch.device('cuda')\n",
    "    dtype = torch.float16\n",
    "    x = torch.randn(bs, seq_len, dim).to(device).to(dtype)\n",
    "    res = torch.randn_like(x)\n",
    "    x.requires_grad_(True)\n",
    "    res.requires_grad_(True)\n",
    "    k = torch.randn(dim, bs).to(device).to(dtype) # 乘上结果，防止dy，dres的stride都为0\n",
    "    stream = torch.cuda.Stream()\n",
    "    torch.cuda.set_stream(stream)\n",
    "\n",
    "    def cal_loss(func, x, res, k):\n",
    "        m,n = func(x, res)\n",
    "        y = m * n\n",
    "        return y.sum()\n",
    "\n",
    "    if provider == 'HF-LlamaAddRMSNorm':\n",
    "        func = LlamaAddRMSNorm(dim).cuda().to(dtype)\n",
    "        loss = cal_loss(func, x, res, k)\n",
    "        ms = triton.testing.do_bench(lambda: loss.backward(retain_graph=True), grad_to_none=[x, res])\n",
    "    if provider == 'Triton-FusedAddRMSNorm':\n",
    "        func = TritonFusedAddRMSNorm(dim).cuda().to(dtype)\n",
    "        loss = cal_loss(func, x, res, k)\n",
    "        ms = triton.testing.do_bench(lambda: loss.backward(retain_graph=True), grad_to_none=[x, res])\n",
    "    if provider == 'Triton-AddRMSNorm':\n",
    "        func = TritonAddRMSNorm(dim).cuda().to(dtype)\n",
    "        loss = cal_loss(func, x, res, k)\n",
    "        ms = triton.testing.do_bench(lambda: loss.backward(retain_graph=True), grad_to_none=[x, res])\n",
    "\n",
    "    return ms * 1e3\n",
    "print(f'bs: {8}, seq_len: {1024}')\n",
    "benchmark.run(show_plots=True, print_data=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bs: 8, seq_len: 1024\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSNorm:\n",
      "        dim  Triton-FusedAddRMSNorm  HF-LlamaAddRMSNorm  Triton-AddRMSNorm\n",
      "0    1024.0              203.983754          365.659446         228.291467\n",
      "1    2048.0              198.899835          727.126360         206.737339\n",
      "2    3072.0              219.983920         1028.235435         280.638039\n",
      "3    4096.0              270.588607         1334.504008         346.062094\n",
      "4    5120.0              349.703997         1630.307078         451.170921\n",
      "5    6144.0              405.576736         1930.040836         521.750450\n",
      "6    7168.0              452.097952         2230.541706         591.282904\n",
      "7    8192.0              504.346907         2528.745174         657.997906\n",
      "8    9216.0              606.610537         2824.479103         780.764997\n",
      "9   10240.0              657.239497         3120.333195         847.524285\n",
      "10  11264.0              728.436947         3416.821003         925.850511\n",
      "11  12288.0              793.402135         3716.742516         987.731814\n",
      "12  13312.0              822.698236         4015.897751        1066.151619\n",
      "13  14336.0              866.059721         4305.634975        1145.044327\n",
      "14  15360.0              928.338528         4609.502792        1202.602267\n",
      "15  16384.0              971.963286         4907.392502        1296.698689\n"
     ]
    }
   ],
   "source": [
    "torch.cuda.empty_cache()\n",
    "@triton.testing.perf_report(\n",
    "    triton.testing.Benchmark(\n",
    "        x_names=['dim'],  # argument names to use as an x-axis for the plot\n",
    "        x_vals=[1024 * i for i in range(1, 16+1)],  # different possible values for `x_name`\n",
    "        line_arg='provider',  # argument name whose value corresponds to a different line in the plot\n",
    "        line_vals=['Triton-FusedAddRMSNorm', 'HF-LlamaAddRMSNorm', 'Triton-AddRMSNorm'],  # possible values for `line_arg``\n",
    "        line_names=[\n",
    "            \"Triton-FusedAddRMSNorm\",\n",
    "            \"HF-LlamaAddRMSNorm\",\n",
    "            \"Triton-AddRMSNorm\"\n",
    "        ],  # label name for the lines\n",
    "        styles=[('blue', '-'), ('green', '-'), ('orange', '-')],  # line styles\n",
    "        ylabel=\"ms\",  # label name for the y-axis\n",
    "        plot_name=\"RMSNorm\",  # name for the plot. Used also as a file name for saving the plot.\n",
    "        args={'seq_len': 1024, 'bs': 4}\n",
    "\n",
    "    ))\n",
    "def benchmark(bs, seq_len, dim, provider):\n",
    "    device = torch.device('cuda')\n",
    "    dtype = torch.float16\n",
    "    x = torch.randn(bs, seq_len, dim).to(device).to(dtype)\n",
    "    res = torch.randn_like(x)\n",
    "    x.requires_grad_(True)\n",
    "    res.requires_grad_(True)\n",
    "    k = torch.randn(dim, bs).to(device).to(dtype) # 乘上结果，防止dy，dres的stride都为0\n",
    "    stream = torch.cuda.Stream()\n",
    "    torch.cuda.set_stream(stream)\n",
    "\n",
    "    def cal_loss(func, x, res, k):\n",
    "        m,n = func(x, res)\n",
    "        y = m * n\n",
    "        return y.sum()\n",
    "\n",
    "    if provider == 'HF-LlamaAddRMSNorm':\n",
    "        func = LlamaAddRMSNorm(dim).cuda().to(dtype)\n",
    "        loss = cal_loss(func, x, res, k)\n",
    "        ms = triton.testing.do_bench(lambda: loss.backward(retain_graph=True), grad_to_none=[x, res])\n",
    "    if provider == 'Triton-FusedAddRMSNorm':\n",
    "        func = TritonFusedAddRMSNorm(dim).cuda().to(dtype)\n",
    "        loss = cal_loss(func, x, res, k)\n",
    "        ms = triton.testing.do_bench(lambda: loss.backward(retain_graph=True), grad_to_none=[x, res])\n",
    "    if provider == 'Triton-AddRMSNorm':\n",
    "        func = TritonAddRMSNorm(dim).cuda().to(dtype)\n",
    "        loss = cal_loss(func, x, res, k)\n",
    "        ms = triton.testing.do_bench(lambda: loss.backward(retain_graph=True), grad_to_none=[x, res])\n",
    "\n",
    "    return ms * 1e3\n",
    "print(f'bs: {8}, seq_len: {1024}')\n",
    "benchmark.run(show_plots=True, print_data=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# forward + backward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bs: 8, seq_len: 1024\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSNorm:\n",
      "        dim  Triton-FusedAddRMSNorm  HF-LlamaAddRMSNorm  Triton-AddRMSNorm\n",
      "0    1024.0              312.786788         1082.774282         370.698899\n",
      "1    2048.0              490.781963         2009.328127         598.080754\n",
      "2    3072.0              658.320963         2854.454041         808.081985\n",
      "3    4096.0              835.531592         3745.017290        1019.921303\n",
      "4    5120.0             1074.729681         4620.774269        1323.258758\n",
      "5    6144.0             1249.752164         5502.821445        1543.424606\n",
      "6    7168.0             1447.869420         6408.534527        1790.728569\n",
      "7    8192.0             1624.331951         7249.459267        1998.551369\n",
      "8    9216.0             1903.211594         8108.747482        2326.001406\n",
      "9   10240.0             2079.409361         8977.203369        2534.174919\n",
      "10  11264.0             2280.172110         9845.845222        2771.609545\n",
      "11  12288.0             2488.277435        10713.479996        2972.722530\n",
      "12  13312.0             2617.849350        11606.843948        3217.644215\n",
      "13  14336.0             2804.503202        12500.996590        3478.409529\n",
      "14  15360.0             3001.127720        13639.925957        3721.541643\n",
      "15  16384.0             3145.936728        14233.412743        3955.395222\n"
     ]
    }
   ],
   "source": [
    "torch.cuda.empty_cache()\n",
    "@triton.testing.perf_report(\n",
    "    triton.testing.Benchmark(\n",
    "        x_names=['dim'],  # argument names to use as an x-axis for the plot\n",
    "        x_vals=[1024 * i for i in range(1, 16+1)],  # different possible values for `x_name`\n",
    "        line_arg='provider',  # argument name whose value corresponds to a different line in the plot\n",
    "        line_vals=['Triton-FusedAddRMSNorm', 'HF-LlamaAddRMSNorm', 'Triton-AddRMSNorm'],  # possible values for `line_arg``\n",
    "        line_names=[\n",
    "            \"Triton-FusedAddRMSNorm\",\n",
    "            \"HF-LlamaAddRMSNorm\",\n",
    "            \"Triton-AddRMSNorm\"\n",
    "        ],  # label name for the lines\n",
    "        styles=[('blue', '-'), ('green', '-'), ('orange', '-')],  # line styles\n",
    "        ylabel=\"ms\",  # label name for the y-axis\n",
    "        plot_name=\"RMSNorm\",  # name for the plot. Used also as a file name for saving the plot.\n",
    "        args={'seq_len': 1024, 'bs': 8}\n",
    "\n",
    "    ))\n",
    "def benchmark(bs, seq_len, dim, provider):\n",
    "    device = torch.device('cuda')\n",
    "    dtype = torch.float16\n",
    "    x = torch.randn(bs, seq_len, dim).to(device).to(dtype)\n",
    "    res = torch.randn_like(x)\n",
    "    x.requires_grad_(True)\n",
    "    res.requires_grad_(True)\n",
    "    k = torch.randn(dim, 2).to(device).to(dtype) # 乘上结果，防止dy，dres的stride都为0\n",
    "    stream = torch.cuda.Stream()\n",
    "    torch.cuda.set_stream(stream)\n",
    "\n",
    "    def for_and_back(func, x, res, k):\n",
    "        m,n = func(x, res)\n",
    "        y = m * n\n",
    "        loss = y.sum()\n",
    "        loss.backward(retain_graph=True)\n",
    "\n",
    "    if provider == 'HF-LlamaAddRMSNorm':\n",
    "        func = LlamaAddRMSNorm(dim).cuda().to(dtype)\n",
    "        ms = triton.testing.do_bench(lambda: for_and_back(func, x, res, k), grad_to_none=[x, res])\n",
    "    if provider == 'Triton-FusedAddRMSNorm':\n",
    "        func = TritonFusedAddRMSNorm(dim).cuda().to(dtype)\n",
    "        ms = triton.testing.do_bench(lambda: for_and_back(func, x, res, k), grad_to_none=[x, res])\n",
    "    if provider == 'Triton-AddRMSNorm':\n",
    "        func = TritonAddRMSNorm(dim).cuda().to(dtype)\n",
    "        ms = triton.testing.do_bench(lambda: for_and_back(func, x, res, k), grad_to_none=[x, res])\n",
    "\n",
    "    return ms * 1e3\n",
    "print(f'bs: {8}, seq_len: {1024}')\n",
    "benchmark.run(show_plots=True, print_data=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
